Jassif Team Institution

const util = require('util');
const fs = require('fs');

// Convert callback-based fs.readFile to Promise-based
const readFile = util.promisify(fs.readFile);

// Format strings with placeholders
const greeting = util.format('Hello, %s! Today is %s', 'Developer', new Date().toDateString());
console.log(greeting);

// Inspect an object with custom options
const obj = {
  name: 'Test',
  nested: { a: 1, b: [2, 3] },
  fn: function() { return 'test'; }
};
console.log(util.inspect(obj, { colors: true, depth: 2 }));

// Use debug logging
const debug = util.debuglog('app');
debug('This will only show if NODE_DEBUG=app');

// Example of using promisify with async/await
async function readConfig() {
  try {
    const data = await readFile('package.json', 'utf8');
    console.log('Package name:', JSON.parse(data).name);
  } catch (err) {
    console.error('Error reading config:', err);
  }
}

readConfig();

// Import the entire module
const util = require('util');

// Import specific functions using destructuring
const { promisify, inspect, format } = require('util');

// Using strict mode (recommended)
const assert = require('assert').strict;

// For TypeScript users
// import * as util from 'util';
// import { promisify, inspect } from 'util';

// Default import
import util from 'util';

// Named imports
import { promisify, inspect } from 'util';

// Rename imports
import { promisify as pify } from 'util';

// Dynamic import (Node.js 14+)
const { promisify } = await import('util');

// Using with TypeScript types
// import * as util from 'util';
// import type { InspectOptions } from 'util';

const util = require('util');

// Basic formatting
const formatted = util.format('Hello, %s!', 'World');
console.log(formatted); // 'Hello, World!'

// Multiple placeholders
const multiFormatted = util.format(
  'My name is %s. I am %d years old and I love %s.',
  'Kai',
  30,
  'Node.js'
);
console.log(multiFormatted);
// 'My name is Kai. I am 30 years old and I love Node.js.'

// Available specifiers
const specifiers = util.format(
  'String: %s, Number: %d, JSON: %j, Character: %c',
  'hello',
  42,
  { name: 'Object' },
  65  // ASCII code for 'A'
);
console.log(specifiers);

// Extra arguments are concatenated with spaces
const extra = util.format('Hello', 'World', 'from', 'Node.js');
console.log(extra); // 'Hello World from Node.js'

const util = require('util');

// Basic usage
const obj = {
  name: 'John',
  age: 30,
  hobbies: ['reading', 'coding'],
  address: {
    city: 'New York',
    country: 'USA'
  },
  toString() {
    return `${this.name}, ${this.age}`;
  }
};

// Default inspection
console.log(util.inspect(obj));

// Custom options
console.log(util.inspect(obj, {
  colors: true, // Add ANSI color codes
  depth: 0, // Only inspect the first level
  showHidden: true, // Show non-enumerable properties
  compact: false, // Don't format objects on a single line
  showProxy: true, // Show proxy details
  maxArrayLength: 3, // Limit array elements displayed
  breakLength: 50, // Line break after 50 characters
  sorted: true // Sort object properties alphabetically
}));

// Circular references
const circular = { name: 'Circular' };
circular.self = circular;
console.log(util.inspect(circular));

const util = require('util');

// Class with custom inspection
class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
    this._private = 'hidden information';
  }
  
  // Custom inspect method
  [util.inspect.custom](depth, options) {
    return `Person(${this.name}, ${this.age})`;
  }
}

const kai = new Person('Kai', 30);

// Custom inspection is used
console.log(util.inspect(kai)); // Person(Kai, 30)

// Directly using console.log also uses custom inspection
console.log(kai); // Person(Kai, 30)

const util = require('util');
const fs = require('fs');

// Convert fs.readFile from callback-based to Promise-based
const readFilePromise = util.promisify(fs.readFile);

// Now we can use it with async/await or Promise chaining
async function readFileExample() {
  try {
    // Using the promisified function
    const data = await readFilePromise('package.json', 'utf8');
    console.log('File content:', data.substring(0, 100) + '...');
    
    // Error handling with try/catch
    return 'File read successfully';
  } catch (err) {
    console.error('Error reading file:', err.message);
    return 'Error reading file';
  }
}

readFileExample().then(result => {
  console.log('Result:', result);
});

const util = require('util');

// A Promise-based function
async function fetchUserData(id) {
  if (!id) {
    throw new Error('ID is required');
  }
  
  // Simulate API request
  return {
    id,
    name: `User ${id}`,
    email: `user${id}@example.com`
  };
}

// Convert to callback-based
const fetchUserDataCallback = util.callbackify(fetchUserData);

// Using the callback-based function
fetchUserDataCallback(1, (err, user) => {
  if (err) {
    console.error('Error:', err);
    return;
  }
  
  console.log('User data:', user);
});

// Error handling
fetchUserDataCallback(null, (err, user) => {
  if (err) {
    console.error('Error occurred:', err.message);
    return;
  }
  
  console.log('User data:', user); // This won't execute
});

const util = require('util');

// Function with custom promisification
function doSomething(options, callback) {
  callback(null, 'regular result');
}

// Define custom promisification
doSomething[util.promisify.custom] = (options) => {
  return Promise.resolve('custom promisified result');
};

// Use the custom promisification
const promisified = util.promisify(doSomething);

// Compare the results
async function compareResults() {
  // Original function with callback
  doSomething({}, (err, result) => {
    console.log('Callback result:', result);
  });

  // Custom promisified function
  const customResult = await promisified({});
  console.log('Promisified result:', customResult);
}

compareResults();

const util = require('util');

// Example values
const values = [
  'string',
  123,
  true,
  Symbol('symbol'),
  { key: 'value' },
  [1, 2, 3],
  null,
  undefined,
  () => {},
  BigInt(123),
  new Date(),
  /regex/,
  Buffer.from('buffer'),
  new Error('error')
];

// Check types for each value
values.forEach(value => {
  console.log(`Value: ${util.inspect(value)}`);
  console.log(`- isArray: ${util.types.isArrayBuffer(value)}`);
  console.log(`- isDate: ${util.types.isDate(value)}`);
  console.log(`- isRegExp: ${util.types.isRegExp(value)}`);
  console.log(`- isNativeError: ${util.types.isNativeError(value)}`);
  console.log(`- isPromise: ${util.types.isPromise(value)}`);
  console.log(`- isPrimitive: ${util.isPrimitive(value)}`);
  console.log(`- isString: ${util.isString(value)}`);
  console.log(`- isNumber: ${util.isNumber(value)}`);
  console.log(`- isBoolean: ${util.isBoolean(value)}`);
  console.log(`- isSymbol: ${util.types.isSymbol(value)}`);
  console.log(`- isNull: ${value === null}`);
  console.log(`- isUndefined: ${value === undefined}`);
  console.log(`- isFunction: ${util.types.isFunction(value)}`);
  console.log(`- isBuffer: ${Buffer.isBuffer(value)}`);
  console.log('---');
});

const util = require('util');

// JavaScript built-in types
console.log('util.types.isDate(new Date()):',
  util.types.isDate(new Date()));
console.log('util.types.isRegExp(/test/):',
  util.types.isRegExp(/test/));
console.log('util.types.isPromise(Promise.resolve()):',
  util.types.isPromise(Promise.resolve()));

// Node.js-specific types
console.log('util.types.isArrayBuffer(new ArrayBuffer(0)):',
  util.types.isArrayBuffer(new ArrayBuffer(0)));
console.log('util.types.isSharedArrayBuffer(new SharedArrayBuffer(0)):',
  util.types.isSharedArrayBuffer(new SharedArrayBuffer(0)));
console.log('util.types.isUint8Array(new Uint8Array()):',
  util.types.isUint8Array(new Uint8Array()));

// More advanced types
console.log('util.types.isProxy(new Proxy({}, {})):',
  util.types.isProxy(new Proxy({}, {})));
console.log('util.types.isExternal(Requiring C++ binding):',
  'Not demonstrated in this example');

const util = require('util');

// Original function
function oldFunction(x, y) {
  return x + y;
}

// Deprecate the function
const deprecatedFunction = util.deprecate(
  oldFunction,
  'oldFunction() is deprecated. Use newFunction() instead.',
  'DEP0001'
);

// New function
function newFunction(x, y) {
  return x + y;
}

// Using the deprecated function will show a warning
console.log('Result:', deprecatedFunction(5, 10));

// Using the new function
console.log('Result:', newFunction(5, 10));

# Show all deprecation warnings
NODE_OPTIONS='--trace-deprecation'

# Show only the first occurrence of each deprecation
NODE_OPTIONS='--no-deprecation'

# Silence all deprecation warnings
NODE_OPTIONS='--no-warnings'

# Turn deprecation warnings into exceptions
NODE_OPTIONS='--throw-deprecation'

// Enable debug logging for specific modules
// NODE_DEBUG=app,db node your-app.js

// In your application
const debugApp = util.debuglog('app');
const debugDB = util.debuglog('db');

// These will only log when 'app' is in NODE_DEBUG
debugApp('Application started with config: %j', config);

// These will only log when 'db' is in NODE_DEBUG
debugDB('Connected to database: %s', connectionString);

// Enable all debug logs (not recommended in production)
// NODE_DEBUG=* node your-app.js

const util = require('util');

// Create debug loggers for different sections
const debugApp = util.debuglog('app');
const debugDB = util.debuglog('db');
const debugAuth = util.debuglog('auth');

// These messages only appear when NODE_DEBUG includes 'app'
debugApp('Application starting...');
debugApp('Configuration loaded from %j', { source: 'config.json' });

// These messages only appear when NODE_DEBUG includes 'db'
debugDB('Connected to database');
debugDB('Query executed: %s', 'SELECT * FROM users');

// These messages only appear when NODE_DEBUG includes 'auth'
debugAuth('User authenticated: %s', 'john.doe');

// To see these messages, run your app with:
// NODE_DEBUG=app,db node your-app.js
console.log('Application running normally (this always shows)');